{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:22:59.146142Z",
     "start_time": "2025-01-23T07:22:59.123996Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:14.660930Z",
     "iopub.status.busy": "2025-01-24T07:17:14.660502Z",
     "iopub.status.idle": "2025-01-24T07:17:16.666153Z",
     "shell.execute_reply": "2025-01-24T07:17:16.665685Z",
     "shell.execute_reply.started": "2025-01-24T07:17:14.660911Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=10, micro=14, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cu124\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 准备数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:16.667437Z",
     "iopub.status.busy": "2025-01-24T07:17:16.667042Z",
     "iopub.status.idle": "2025-01-24T07:17:20.392093Z",
     "shell.execute_reply": "2025-01-24T07:17:20.391509Z",
     "shell.execute_reply.started": "2025-01-24T07:17:16.667419Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking in indexes: https://mirrors.cloud.aliyuncs.com/pypi/simple\n",
      "Requirement already satisfied: tensorflow in /usr/local/lib/python3.10/site-packages (2.18.0)\n",
      "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (2.1.0)\n",
      "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (1.6.3)\n",
      "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.10/site-packages (from tensorflow) (25.1.21)\n",
      "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.10/site-packages (from tensorflow) (0.6.0)\n",
      "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.10/site-packages (from tensorflow) (0.2.0)\n",
      "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (18.1.1)\n",
      "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.10/site-packages (from tensorflow) (3.4.0)\n",
      "Requirement already satisfied: packaging in /usr/local/lib/python3.10/site-packages (from tensorflow) (24.2)\n",
      "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.10/site-packages (from tensorflow) (5.29.2)\n",
      "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (2.32.3)\n",
      "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/site-packages (from tensorflow) (69.5.1)\n",
      "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (1.17.0)\n",
      "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (2.5.0)\n",
      "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.10/site-packages (from tensorflow) (4.12.2)\n",
      "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (1.17.0)\n",
      "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.10/site-packages (from tensorflow) (1.69.0)\n",
      "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.10/site-packages (from tensorflow) (2.18.0)\n",
      "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (3.8.0)\n",
      "Requirement already satisfied: numpy<2.1.0,>=1.26.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (1.26.4)\n",
      "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (3.12.1)\n",
      "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (0.4.1)\n",
      "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.10/site-packages (from tensorflow) (0.37.1)\n",
      "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.10/site-packages (from astunparse>=1.6.0->tensorflow) (0.44.0)\n",
      "Requirement already satisfied: rich in /usr/local/lib/python3.10/site-packages (from keras>=3.5.0->tensorflow) (13.9.4)\n",
      "Requirement already satisfied: namex in /usr/local/lib/python3.10/site-packages (from keras>=3.5.0->tensorflow) (0.0.8)\n",
      "Requirement already satisfied: optree in /usr/local/lib/python3.10/site-packages (from keras>=3.5.0->tensorflow) (0.14.0)\n",
      "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/site-packages (from requests<3,>=2.21.0->tensorflow) (3.4.1)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/site-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n",
      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/site-packages (from requests<3,>=2.21.0->tensorflow) (2.3.0)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/site-packages (from requests<3,>=2.21.0->tensorflow) (2024.12.14)\n",
      "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/site-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.7)\n",
      "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/site-packages (from tensorboard<2.19,>=2.18->tensorflow) (0.7.2)\n",
      "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/site-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.1.3)\n",
      "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/site-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow) (2.1.5)\n",
      "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.10/site-packages (from rich->keras>=3.5.0->tensorflow) (3.0.0)\n",
      "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/site-packages (from rich->keras>=3.5.0->tensorflow) (2.19.0)\n",
      "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.10/site-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow) (0.1.2)\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.3.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.3.1\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:01.176745Z",
     "start_time": "2025-01-23T07:22:59.195942Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:20.393055Z",
     "iopub.status.busy": "2025-01-24T07:17:20.392784Z",
     "iopub.status.idle": "2025-01-24T07:17:24.458010Z",
     "shell.execute_reply": "2025-01-24T07:17:24.457503Z",
     "shell.execute_reply.started": "2025-01-24T07:17:20.393035Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-24 15:17:20.555525: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2025-01-24 15:17:20.566924: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "E0000 00:00:1737703040.581236     964 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "E0000 00:00:1737703040.585513     964 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2025-01-24 15:17:20.599953: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow import keras\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words = vocab_size, index_from = index_from)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:01.180252Z",
     "start_time": "2025-01-23T07:23:01.176745Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:24.459638Z",
     "iopub.status.busy": "2025-01-24T07:17:24.459042Z",
     "iopub.status.idle": "2025-01-24T07:17:24.462372Z",
     "shell.execute_reply": "2025-01-24T07:17:24.461904Z",
     "shell.execute_reply.started": "2025-01-24T07:17:24.459618Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train (25000,) (25000,)\n",
      "test (25000,) (25000,)\n"
     ]
    }
   ],
   "source": [
    "print(\"train\", train_data.shape, train_labels.shape)\n",
    "print(\"test\", test_data.shape, test_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:01.216074Z",
     "start_time": "2025-01-23T07:23:01.180759Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:24.463838Z",
     "iopub.status.busy": "2025-01-24T07:17:24.463510Z",
     "iopub.status.idle": "2025-01-24T07:17:24.505969Z",
     "shell.execute_reply": "2025-01-24T07:17:24.505500Z",
     "shell.execute_reply.started": "2025-01-24T07:17:24.463823Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构造 word2idx 和 idx2word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:01.232452Z",
     "start_time": "2025-01-23T07:23:01.217078Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:24.506833Z",
     "iopub.status.busy": "2025-01-24T07:17:24.506546Z",
     "iopub.status.idle": "2025-01-24T07:17:24.535022Z",
     "shell.execute_reply": "2025-01-24T07:17:24.534546Z",
     "shell.execute_reply.started": "2025-01-24T07:17:24.506816Z"
    }
   },
   "outputs": [],
   "source": [
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,     # 填充 token\n",
    "    \"[BOS]\": 1,     # begin of sentence\n",
    "    \"[UNK]\": 2,     # 未知 token\n",
    "    \"[EOS]\": 3,     # end of sentence\n",
    "})\n",
    "\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:01.677464Z",
     "start_time": "2025-01-23T07:23:01.232452Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:24.535869Z",
     "iopub.status.busy": "2025-01-24T07:17:24.535586Z",
     "iopub.status.idle": "2025-01-24T07:17:25.427531Z",
     "shell.execute_reply": "2025-01-24T07:17:25.427048Z",
     "shell.execute_reply.started": "2025-01-24T07:17:24.535852Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "for text in train_data:\n",
    "    length = len(text)\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "    \n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:01.687290Z",
     "start_time": "2025-01-23T07:23:01.677464Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:25.428341Z",
     "iopub.status.busy": "2025-01-24T07:17:25.428128Z",
     "iopub.status.idle": "2025-01-24T07:17:25.437903Z",
     "shell.execute_reply": "2025-01-24T07:17:25.437316Z",
     "shell.execute_reply.started": "2025-01-24T07:17:25.428325Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   0,    0,    0,    1, 4825,  182,    3])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   0,    1,   14,    9,    6, 2181,    3])\n",
      "decode text\n",
      "[PAD] [PAD] [PAD] [BOS] hello world [EOS]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[PAD] [BOS] this is a test [EOS]\n"
     ]
    }
   ],
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx\n",
    "        self.idx2word = idx2word\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx\n",
    "        self.bos_idx = bos_idx\n",
    "        self.eos_idx = eos_idx\n",
    "        self.unk_idx = unk_idx\n",
    "    \n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"如果padding_first == True，则padding加载前面，否则加载后面\"\"\"\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length-2]] + [self.eos_idx] #直接切片取前max_length-2个单词，然后加上bos和eos\n",
    "            if padding_first:\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)\n",
    "    \n",
    "    \n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "    \n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=True)\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "print(\"decode text\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:01.690860Z",
     "start_time": "2025-01-23T07:23:01.687290Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:25.438992Z",
     "iopub.status.busy": "2025-01-24T07:17:25.438543Z",
     "iopub.status.idle": "2025-01-24T07:17:25.443508Z",
     "shell.execute_reply": "2025-01-24T07:17:25.442927Z",
     "shell.execute_reply.started": "2025-01-24T07:17:25.438961Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\",\n",
       " \"[BOS] big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal [UNK] the hair is big lots of boobs [UNK] men wear those cut [UNK] shirts that show off their [UNK] sickening that men actually wore them and the music is just [UNK] trash that plays over and over again in almost every scene there is trashy music boobs and [UNK] taking away bodies and the gym still doesn't close for [UNK] all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\"]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 看看训练集的数据\n",
    "\n",
    "tokenizer.decode(train_data[:2], remove_bos=False, remove_eos=False, remove_pad=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集与 DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.702763Z",
     "start_time": "2025-01-23T07:23:01.690860Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:25.444589Z",
     "iopub.status.busy": "2025-01-24T07:17:25.444217Z",
     "iopub.status.idle": "2025-01-24T07:17:27.611373Z",
     "shell.execute_reply": "2025-01-24T07:17:27.610908Z",
     "shell.execute_reply.started": "2025-01-24T07:17:25.444561Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    \n",
    "def collate_fct(batch):\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 这里使用 padding first\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "# 用RNN，缩短序列长度\n",
    "train_ds = IMDBDataset(train_data, train_labels, remain_length=False)\n",
    "test_ds = IMDBDataset(test_data, test_labels, remain_length=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.705768Z",
     "start_time": "2025-01-23T07:23:02.702763Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.612126Z",
     "iopub.status.busy": "2025-01-24T07:17:27.611917Z",
     "iopub.status.idle": "2025-01-24T07:17:27.617859Z",
     "shell.execute_reply": "2025-01-24T07:17:27.617464Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.612110Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.726106Z",
     "start_time": "2025-01-23T07:23:02.706888Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.618678Z",
     "iopub.status.busy": "2025-01-24T07:17:27.618321Z",
     "iopub.status.idle": "2025-01-24T07:17:27.638265Z",
     "shell.execute_reply": "2025-01-24T07:17:27.637749Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.618660Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 500]) torch.Size([128, 1])\n"
     ]
    }
   ],
   "source": [
    "for text, label in train_dl:\n",
    "    print(text.shape, label.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.731011Z",
     "start_time": "2025-01-23T07:23:02.726106Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.639273Z",
     "iopub.status.busy": "2025-01-24T07:17:27.638901Z",
     "iopub.status.idle": "2025-01-24T07:17:27.646065Z",
     "shell.execute_reply": "2025-01-24T07:17:27.645681Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.639252Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================== 一层单向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        super(RNN, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.rnn = nn.RNN(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=bidirectional)\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim)\n",
    "        self.fc = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # [bs, seq length]\n",
    "        x = self.embeding(x)\n",
    "        # [bs, seq length, embedding_dim] -> shape [bs, embedding_dim, seq length]\n",
    "        seq_output, final_hidden = self.rnn(x)\n",
    "        # print(f'seq_output.shape={seq_output.shape}')\n",
    "        # print(f'final_hidden.shape={final_hidden.shape}')\n",
    "        # [bs, seq length, hidden_dim], [*, bs, hidden_dim]\n",
    "        x = seq_output[:, -1, :]\n",
    "        # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "    \n",
    "\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层单向 RNN \"))       \n",
    "for key, value in RNN().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.739805Z",
     "start_time": "2025-01-23T07:23:02.731011Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.647981Z",
     "iopub.status.busy": "2025-01-24T07:17:27.647642Z",
     "iopub.status.idle": "2025-01-24T07:17:27.662720Z",
     "shell.execute_reply": "2025-01-24T07:17:27.662334Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.647966Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#做前向计算，看下输出的shape\n",
    "model = RNN()  \n",
    "sample_inputs = torch.randint(0, vocab_size, (1, 500))\n",
    "model(sample_inputs).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.742848Z",
     "start_time": "2025-01-23T07:23:02.739805Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.663347Z",
     "iopub.status.busy": "2025-01-24T07:17:27.663159Z",
     "iopub.status.idle": "2025-01-24T07:17:27.666167Z",
     "shell.execute_reply": "2025-01-24T07:17:27.665751Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.663332Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "64*64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.745356Z",
     "start_time": "2025-01-23T07:23:02.742848Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.666725Z",
     "iopub.status.busy": "2025-01-24T07:17:27.666584Z",
     "iopub.status.idle": "2025-01-24T07:17:27.668838Z",
     "shell.execute_reply": "2025-01-24T07:17:27.668399Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.666711Z"
    }
   },
   "outputs": [],
   "source": [
    "# print(\"{:=^80}\".format(\" 一层双向 RNN \"))       \n",
    "# for key, value in RNN(bidirectional=True).named_parameters():\n",
    "#     print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "# \n",
    "#     \n",
    "# print(\"{:=^80}\".format(\" 俩层单向 RNN \"))       \n",
    "# for key, value in RNN(num_layers=2).named_parameters():\n",
    "#     print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.749811Z",
     "start_time": "2025-01-23T07:23:02.746361Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.669390Z",
     "iopub.status.busy": "2025-01-24T07:17:27.669244Z",
     "iopub.status.idle": "2025-01-24T07:17:27.695224Z",
     "shell.execute_reply": "2025-01-24T07:17:27.694826Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.669365Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.753996Z",
     "start_time": "2025-01-23T07:23:02.749811Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.696099Z",
     "iopub.status.busy": "2025-01-24T07:17:27.695754Z",
     "iopub.status.idle": "2025-01-24T07:17:27.737678Z",
     "shell.execute_reply": "2025-01-24T07:17:27.737233Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.696082Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.757931Z",
     "start_time": "2025-01-23T07:23:02.753996Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.738359Z",
     "iopub.status.busy": "2025-01-24T07:17:27.738166Z",
     "iopub.status.idle": "2025-01-24T07:17:27.742472Z",
     "shell.execute_reply": "2025-01-24T07:17:27.742091Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.738344Z"
    }
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T07:23:02.761322Z",
     "start_time": "2025-01-23T07:23:02.757931Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.743069Z",
     "iopub.status.busy": "2025-01-24T07:17:27.742923Z",
     "iopub.status.idle": "2025-01-24T07:17:27.746593Z",
     "shell.execute_reply": "2025-01-24T07:17:27.746192Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.743054Z"
    }
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2025-01-23T07:23:34.873252Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-24T07:17:27.747462Z",
     "iopub.status.busy": "2025-01-24T07:17:27.747285Z",
     "iopub.status.idle": "2025-01-24T07:19:49.594127Z",
     "shell.execute_reply": "2025-01-24T07:19:49.593526Z",
     "shell.execute_reply.started": "2025-01-24T07:17:27.747447Z"
    },
    "jupyter": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3920/3920 [02:20<00:00, 27.83it/s, epoch=19]\n"
     ]
    }
   ],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 20\n",
    "\n",
    "# model = RNN(bidirectional=True) #双向单层\n",
    "model = RNN(num_layers=2)\n",
    "# model = RNN()\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-rnn\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-rnn\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    test_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-24T07:19:49.595723Z",
     "iopub.status.busy": "2025-01-24T07:19:49.594928Z",
     "iopub.status.idle": "2025-01-24T07:19:49.764169Z",
     "shell.execute_reply": "2025-01-24T07:19:49.763612Z",
     "shell.execute_reply.started": "2025-01-24T07:19:49.595689Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-24T07:19:49.765429Z",
     "iopub.status.busy": "2025-01-24T07:19:49.764948Z",
     "iopub.status.idle": "2025-01-24T07:19:52.882842Z",
     "shell.execute_reply": "2025-01-24T07:19:52.882374Z",
     "shell.execute_reply.started": "2025-01-24T07:19:49.765393Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_964/739210218.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(\"checkpoints/imdb-rnn/best.ckpt\", map_location=\"cpu\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.5733\n",
      "accuracy: 0.7214\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-rnn/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [],
   "dockerImageVersionId": 30616,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
